Positioning Verfification in the Context of Software/System Certification

Formal verification applied to software has been seen as an important focus in research for determining the acceptability of that software for use. However, in examining the requirements for determining the safety of a software intensive system for use in critical situations, it is quite clear that verification plays a role,but not necessarily a central role. It is entirely possible that a piece of software satisfies its specification, but is unsafe to use. (The first and foremost reason for this is that the program satisfies an unsafe specification.) In this paper we will address the nature of certification in the context of critical systems, decomposing it,by means of a new philosophical framework, into four aspects: evidence, confidence, determination and certification. Our point of view is that establishing the safety (in a very general sense) of a system is a confidence building exercise much in the same vein as the scientific method; our framework serves as a setting in which we can properly understand and develop such an exercise. We will then place formal verification and assurance cases in this setting, discussing their roles and limitations.Keywords: Software certification, System certification, Formal specification, Verification,Critical systems, Safety, Assurance cases, Safety case

A Logic for Real-Time Systems Specification, Its Algebraic Semantics, and Equational Calculus

We present a logic for real time systems specification which is an extension of first order dynamic logic by adding (a) arbitrary atomic actions rather than only assignments, (b) variables over actions which allow to specify systems partially, and (c) explicit time. The logic is algebraized using closure fork algebras and a representation theorem for this class is presented. This allows to define an equational (but infinitary) proof system for the algebraization.Laboratorio de Investigación y Formación en Informática Avanzad

Category Theory and Model-Driven Engineering: From Formal Semantics to Design Patterns and Beyond

There is a hidden intrigue in the title. CT is one of the most abstract mathematical disciplines, sometimes nicknamed "abstract nonsense". MDE is a recent trend in software development, industrially supported by standards, tools, and the status of a new "silver bullet". Surprisingly, categorical patterns turn out to be directly applicable to mathematical modeling of structures appearing in everyday MDE practice. Model merging, transformation, synchronization, and other important model management scenarios can be seen as executions of categorical specifications. Moreover, the paper aims to elucidate a claim that relationships between CT and MDE are more complex and richer than is normally assumed for "applied mathematics". CT provides a toolbox of design patterns and structural principles of real practical value for MDE. We will present examples of how an elementary categorical arrangement of a model management scenario reveals deficiencies in the architecture of modern tools automating the scenario.Comment: In Proceedings ACCAT 2012, arXiv:1208.430

A Conceptual Framework for BX

Non UBCUnreviewedAuthor affiliation: McMaster UniversityFacult

Temporal Specifications of Component Based Systems with Polymorphic Dynamic Reconfiguration

In this chapter, we present a formal characterisation of component based systems with support for polymorphic dynamic reconfiguration. By dynamic reconfiguration we mean, as usual, changes in the system architecture at run time. By polymorphic reconfiguration we mean that reconfiguration operations may concern different types of components or connections, exploiting an inheritance relationship over components, as in object orientation. The formal characterisation of component based systems is based on a firstorder temporal logic. The logic is a variant of the Manna-Pnueli logic, expressive enough for straightforward specification of component types, connector types and dynamic amalgamations of components. On top of this logic, and in the form of a (rather low level) specification language, we build the necessary machinery for specifying components, connectors and amalgamations, together with inheritance and polymorphism. When the complexity of software systems started to increase some decades ago, i